Pandas DataFrame Izveide: Dziļš Ieskats Datu Struktūru Inicializācijā

Laipni lūdzam datu manipulāciju pasaulē ar Python! Gandrīz katra datu analīzes uzdevuma pamatā ir Pandas bibliotēka, un tās stūrakmens ir DataFrame. Iedomājieties DataFrame kā viedu, jaudīgu un elastīgu izklājlapas vai datubāzes tabulas versiju, kas atrodas tieši jūsu Python vidē. Tas ir galvenais rīks datu tīrīšanai, pārveidošanai, analizēšanai un vizualizācijai. Bet pirms varat veikt šo datu maģiju, jums vispirms jāapgūst DataFrame izveides māksla. Veids, kā jūs inicializējat šo fundamentālo datu struktūru, var noteikt pamatu visai jūsu analīzei.

Šī visaptverošā rokasgrāmata ir paredzēta plašam topošo un praktizējošo datu analītiķu, zinātnieku un inženieru lokam. Mēs izpētīsim visizplatītākās un jaudīgākās metodes Pandas DataFrame izveidei no nulles. Neatkarīgi no tā, vai jūsu dati ir vārdnīcā, sarakstā, NumPy masīvā vai citā formātā, šis raksts sniegs jums zināšanas un praktiskus piemērus, lai ar pārliecību un efektivitāti inicializētu savus DataFrame. Veidosim savu pamatu.

Kas īsti ir Pandas DataFrame?

Pirms sākam būvēt, noskaidrosim, ko mēs konstruējam. Pandas DataFrame ir divdimensiju, izmēru ziņā maināma un potenciāli heterogēna tabulas datu struktūra. Sadalīsim to:

• Divdimensiju: Tam ir rindas un kolonnas, tāpat kā izklājlapai.
• Izmēru ziņā maināms: Jūs varat pievienot vai noņemt rindas un kolonnas pēc DataFrame izveides.
• Heterogēns: Kolonnām var būt dažādi datu tipi. Piemēram, viena kolonna var saturēt skaitļus (veselus skaitļus vai peldošos punktus), cita var saturēt tekstu (virknes), bet trešā var saturēt datumus vai Būla vērtības (True/False).

DataFrame ir trīs galvenās sastāvdaļas:

1. Dati: Faktiskās vērtības, kas atrodas struktūrā, sakārtotas rindās un kolonnās.
2. Indekss: Rindu etiķetes. Ja jūs nenodrošināt indeksu, Pandas izveido noklusējuma indeksu, sākot no 0. Indekss nodrošina jaudīgu veidu, kā piekļūt datiem un tos saskaņot.
3. Kolonnas: Kolonnu etiķetes. Tās ir ļoti svarīgas, lai piekļūtu noteiktām datu sērijām DataFrame.

Izpratne par šo struktūru ir būtiska, lai saprastu, kā efektīvi izveidot un manipulēt ar DataFrame.

Pamats: Pandas Importēšana

Vispirms. Lai izmantotu Pandas, jums ir jāimportē bibliotēka savā Python skriptā vai piezīmju grāmatiņā. Vispārpieņemtā konvencija, kurai seko profesionāļi visā pasaulē, ir importēt to ar aizstājvārdu pd. Šis vienkāršais aizstājvārds padara jūsu kodu lasāmāku un kodolīgāku.

import pandas as pd
import numpy as np # Bieži izmanto kopā ar Pandas, tāpēc mēs to arī importēsim.

Ar šo vienu rindiņu jūs esat atraisījis visu Pandas bibliotēkas spēku. Tagad ķersimies pie šīs rokasgrāmatas būtības: DataFrame izveides.

Galvenās Izveides Metodes: No Vienkāršām līdz Sarežģītām

pd.DataFrame() konstruktors ir neticami daudzpusīgs. Tas var pieņemt daudzus dažādus ievades veidus. Tagad mēs izpētīsim būtiskākās metodes, pārejot no visizplatītākajām uz specializētākiem gadījumiem.

1. DataFrame Izveide no Sarakstu vai Masīvu Vārdnīcas

Šī, iespējams, ir visizplatītākā un intuitīvākā metode DataFrame izveidei. Jūs sākat ar Python vārdnīcu, kur atslēgas kļūs par kolonnu nosaukumiem, un vērtības būs saraksti (vai NumPy masīvi vai Pandas Series), kas satur datus katrai kolonnai.

Kā tas darbojas: Pandas kartē katru vārdnīcas atslēgu uz kolonnas virsrakstu un katru vērtību sarakstu uz šīs kolonnas rindām. Šeit būtiska prasība ir, lai visiem sarakstiem būtu vienāds garums, jo katrs saraksts attēlo pilnu datu kolonnu.

Piemērs:

Izveidosim DataFrame, kas satur informāciju par dažādām pilsētām visā pasaulē.

# Dati sakārtoti pa kolonnām city_data = { 'City': ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'], 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } # Izveidot DataFrame df_from_dict = pd.DataFrame(city_data) print(df_from_dict)

Rezultāts:

         City Country  Population_Millions  Is_Coastal
0       Tokyo   Japan                 37.3        True
1       Delhi   India                 32.0       False
2    Shanghai   China                 28.5        True
3   São Paulo  Brazil                 22.4       False
4      Mumbai   India                 20.9        True

Galvenā atziņa: Šī metode ir lieliski piemērota, ja jūsu dati ir dabiski sakārtoti pēc funkcijas vai kategorijas. Tas ir tīrs, lasāms un tieši pārvērš jūsu vārdnīcas struktūru tabulas formātā.

2. DataFrame Izveide no Vārdnīcu Saraksta

Alternatīva un tikpat jaudīga metode ir izmantot sarakstu, kur katrs elements ir vārdnīca. Šajā struktūrā katra vārdnīca attēlo vienu rindu, un tās atslēgas attēlo kolonnu nosaukumus šīs rindas datiem.

Kā tas darbojas: Pandas iterē cauri sarakstam. Katrai vārdnīcai tā izveido jaunu rindu. Vārdnīcas atslēgas tiek izmantotas, lai noteiktu kolonnas. Šī metode ir neticami elastīga, jo, ja vārdnīcai trūkst atslēgas, Pandas automātiski aizpildīs šo šūnu atbilstošajā rindā ar NaN (Not a Number), kas ir standarta marķieris trūkstošiem datiem Pandas.

Piemērs:

Attēlosim tos pašus pilsētas datus, bet šoreiz strukturētus kā ierakstu sarakstu.

# Dati sakārtoti pa rindām (ierakstiem) records_data = [ {'City': 'Tokyo', 'Country': 'Japan', 'Population_Millions': 37.3, 'Is_Coastal': True}, {'City': 'Delhi', 'Country': 'India', 'Population_Millions': 32.0, 'Is_Coastal': False}, {'City': 'Shanghai', 'Country': 'China', 'Population_Millions': 28.5}, {'City': 'São Paulo', 'Country': 'Brazil', 'Population_Millions': 22.4, 'Is_Coastal': False}, {'City': 'Cairo', 'Country': 'Egypt', 'Timezone': 'EET'} # Ievērojiet atšķirīgo struktūru ] # Izveidot DataFrame df_from_list_of_dicts = pd.DataFrame(records_data) print(df_from_list_of_dicts)

Rezultāts:

         City Country  Population_Millions  Is_Coastal Timezone
0       Tokyo   Japan                 37.3        True      NaN
1       Delhi   India                 32.0       False      NaN
2    Shanghai   China                 28.5         NaN      NaN
3   São Paulo  Brazil                 22.4       False      NaN
4       Cairo   Egypt                  NaN         NaN      EET

Ievērojiet, kā Pandas graciozi apstrādāja neatbilstības. Shanghai vērtība 'Is_Coastal' ir NaN, jo tā trūka no tās vārdnīcas. Kairai tika izveidota jauna kolonna 'Timezone', ar NaN visām pārējām pilsētām. Tas padara to par lielisku izvēli darbam ar daļēji strukturētiem datiem, piemēram, JSON atbildēm no API.

Galvenā atziņa: Izmantojiet šo metodi, ja jūsu dati tiek iegūti kā ierakstu vai novērojumu sērija. Tas ir izturīgs, apstrādājot trūkstošus datus un variācijas ierakstu struktūrā.

3. DataFrame Izveide no NumPy Masīva

Tiem, kas strādā zinātniskajā skaitļošanā, mašīnmācībā vai jebkurā jomā, kas saistīta ar smagām skaitliskām operācijām, dati bieži vien rodas NumPy masīvos. Pandas ir veidots uz NumPy pamata, padarot integrāciju starp abiem nemanāmu un ļoti efektīvu.

Kā tas darbojas: Jūs nododat 2D NumPy masīvu pd.DataFrame() konstruktoram. Pēc noklusējuma Pandas izveidos uz veseliem skaitļiem balstītus indeksus un kolonnas. Tomēr jūs varat (un vajadzētu) nodrošināt jēgpilnas etiķetes, izmantojot parametrus index un columns.

Piemērs:

Izveidosim DataFrame no nejauši ģenerēta 5x4 NumPy masīva, kas attēlo sensoru rādījumus laika gaitā.

# Izveidot 5x4 NumPy masīvu ar nejaušiem datiem data_np = np.random.rand(5, 4) # Definēt kolonnu un indeksa etiķetes columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D'] index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04']) # Izveidot DataFrame df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns) print(df_from_numpy)

Rezultāts (jūsu nejaušie skaitļi atšķirsies):

                           Sensor_A  Sensor_B  Sensor_C  Sensor_D
2023-10-27 10:00:00  0.123456  0.987654  0.555555  0.111111
2023-10-27 10:01:00  0.234567  0.876543  0.666666  0.222222
2023-10-27 10:02:00  0.345678  0.765432  0.777777  0.333333
2023-10-27 10:03:00  0.456789  0.654321  0.888888  0.444444
2023-10-27 10:04:00  0.567890  0.543210  0.999999  0.555555

Šajā piemērā mēs ieviesām arī jaudīgu funkciju: DatetimeIndex izmantošanu laika rindu datiem, kas Pandas atbloķē plašu laika bāzes analīzes iespēju klāstu.

Galvenā atziņa: Šī ir visefektīvākā atmiņas metode, lai izveidotu DataFrame no homogēniem skaitliskiem datiem. Tā ir standarta izvēle, saskaroties ar tādām bibliotēkām kā NumPy, Scikit-learn vai TensorFlow.

4. DataFrame Izveide no Sarakstu Saraksta

Šī metode ir konceptuāli līdzīga izveidei no NumPy masīva, bet izmanto standarta Python sarakstus. Tas ir vienkāršs veids, kā konvertēt tabulas datus, kas saglabāti ligzdotā saraksta formātā.

Kā tas darbojas: Jūs nodrošināt sarakstu, kur katrs iekšējais saraksts attēlo datu rindu. Tāpat kā ar NumPy masīviem, ir ļoti ieteicams norādīt kolonnu nosaukumus, izmantojot parametru columns, lai nodrošinātu skaidrību.

Piemērs:

# Dati kā rindu saraksts product_data = [ ['P001', 'Laptop', 1200.00, 'Electronics'], ['P002', 'Mouse', 25.50, 'Electronics'], ['P003', 'Desk Chair', 150.75, 'Furniture'], ['P004', 'Keyboard', 75.00, 'Electronics'] ] # Definēt kolonnu nosaukumus column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category'] # Izveidot DataFrame df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names) print(df_from_list_of_lists)

Rezultāts:

  ProductID ProductName  Price_USD     Category
0      P001      Laptop    1200.00  Electronics
1      P002       Mouse      25.50  Electronics
2      P003  Desk Chair     150.75    Furniture
3      P004    Keyboard      75.00  Electronics

Galvenā atziņa: Šī ir vienkārša un efektīva metode, ja jūsu dati jau ir strukturēti kā rindu saraksts, piemēram, lasot no faila formāta, kuram nav galvenes.

Papildu Inicializācija: DataFrame Pielāgošana

Papildus neapstrādātu datu nodrošināšanai, pd.DataFrame() konstruktors piedāvā vairākus parametrus, lai kontrolētu jūsu jaunā DataFrame struktūru un īpašības no tā izveides brīža.

Indeksa Norādīšana

Mēs jau esam redzējuši parametru `index` darbībā. Indekss ir būtiska DataFrame daļa, kas nodrošina rindu etiķetes, kuras tiek izmantotas ātrai uzmeklēšanai, datu saskaņošanai un citam. Lai gan Pandas nodrošina noklusējuma skaitlisko indeksu (0, 1, 2, ...), jēgpilna indeksa iestatīšana var ievērojami atvieglot darbu ar jūsu datiem.

Piemērs: Atkārtoti izmantosim mūsu sarakstu vārdnīcas piemēru, bet iestatīsim kolonnu `City` kā indeksu izveides brīdī.

city_data = { 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } city_names = ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'] # Izveidot DataFrame ar pielāgotu indeksu df_with_index = pd.DataFrame(city_data, index=city_names) print(df_with_index)

Rezultāts:

          Country  Population_Millions  Is_Coastal
Tokyo       Japan                 37.3        True
Delhi       India                 32.0       False
Shanghai    China                 28.5        True
São Paulo  Brazil                 22.4       False
Mumbai      India                 20.9        True

Tagad jūs varat piekļūt rindu datiem, izmantojot šīs jēgpilnās etiķetes, piemēram, ar df_with_index.loc['Tokyo'].

Datu Tipu Kontrole (`dtype`)

Pandas diezgan labi nosaka datu tipus (piemēram, atpazīstot skaitļus, tekstu un Būla vērtības). Tomēr dažreiz jums ir jāpiemēro noteikts datu tips kolonnai, lai nodrošinātu atmiņas efektivitāti vai iespējotu noteiktas darbības. Parametrs `dtype` dod jums šo kontroli.

Piemērs: Iedomājieties, ka mums ir produktu ID, kas izskatās kā skaitļi, bet tie jāuztver kā teksts (virknes).

data = { 'ProductID': [101, 102, 103], 'Stock': [50, 75, 0] } # Izveidot DataFrame, norādot 'ProductID' dtype df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'}) print(df_types.dtypes)

Rezultāts:

ProductID    object
Stock         int32
dtype: object

Ievērojiet, ka `str` Pandas tiek attēlots kā `object`. Skaidri iestatot `dtype`, mēs neļaujam Pandas uztvert `ProductID` kā skaitli, kas vēlāk varētu izraisīt nepareizus aprēķinus vai šķirošanas problēmas. Izmantojot specifiskākus veselo skaitļu tipus, piemēram, `int32`, nevis noklusējuma `int64`, var arī ievērojami ietaupīt atmiņu ar lieliem datu kopumiem.

Praktiski Scenāriji un Labākā Prakse

Pareizas izveides metodes izvēle ir atkarīga no jūsu datu sākotnējā formāta. Šeit ir vienkāršs lēmumu pieņemšanas ceļvedis:

• Vai jūsu dati ir kolonnās (piemēram, viens saraksts katrai funkcijai)? Izmantojiet sarakstu vārdnīcu. Tas ir dabisks piemērs.
• Vai jūsu dati ir ierakstu sērija (piemēram, no JSON API)? Izmantojiet vārdnīcu sarakstu. Tas lieliski apstrādā trūkstošus vai papildu laukus ierakstos.
• Vai jūsu dati ir skaitliski un režģī (piemēram, no zinātniskiem aprēķiniem)? Izmantojiet NumPy masīvu. Tas ir visefektīvākais variants šajā gadījumā.
• Vai jūsu dati ir vienkāršā tabulas formātā rindu pa rindai bez galvenēm? Izmantojiet sarakstu sarakstu un atsevišķi norādiet kolonnu nosaukumus.

Biežākās Kļūdas, No Kurām Jāizvairās

1. Nevienāds Garums Sarakstu Vārdnīcā: Šī ir izplatīta kļūda. Izveidojot DataFrame no sarakstu vārdnīcas, katram sarakstam ir jābūt tieši tādam pašam elementu skaitam. Ja nē, Pandas izraisīs `ValueError`. Pirms izveides vienmēr pārliecinieties, vai jūsu kolonnu dati ir vienāda garuma.
2. Indeksa Ignorēšana: Paļaušanās uz noklusējuma indeksu, kas balstīts uz 0, ir piemērots daudzos gadījumos, bet, ja jūsu datiem ir dabisks identifikators (piemēram, produkta ID, lietotāja ID vai konkrēts laika zīmogs), tā iestatīšana kā indekss no paša sākuma var vienkāršot jūsu kodu vēlāk.
3. Aizmirst Datu Tipus: Ļaujot Pandas noteikt tipus, lielākoties darbojas, bet lieliem datu kopumiem vai kolonnām ar jauktiem tipiem var ciest veiktspēja. Esiet proaktīvs attiecībā uz `dtype` iestatīšanu kolonnām, kuras jāuztver kā kategorijas, virknes vai specifiski skaitliski tipi, lai ietaupītu atmiņu un novērstu kļūdas.

Papildus Inicializācijai: DataFrame Izveide no Failiem

Lai gan šī rokasgrāmata koncentrējas uz DataFrame izveidi no Python objektiem atmiņā, ir svarīgi zināt, ka lielākajā daļā reālās pasaules scenāriju jūsu dati tiks iegūti no ārēja faila. Pandas nodrošina ļoti optimizētu lasītāju funkciju komplektu šim nolūkam, ieskaitot:

• pd.read_csv(): Komatu atdalītu vērtību failiem, datu importa darba zirgs.
• pd.read_excel(): Datu lasīšanai no Microsoft Excel izklājlapām.
• pd.read_json(): Datu lasīšanai no JSON failiem vai virknēm.
• pd.read_sql(): Datubāzes vaicājuma rezultātu lasīšanai tieši DataFrame.
• pd.read_parquet(): Lasīšanai no efektīva, uz kolonnām orientēta Parquet faila formāta.

Šīs funkcijas ir nākamais loģiskais solis jūsu Pandas ceļojumā. To apgūšana ļaus jums ievadīt datus no praktiski jebkura avota jaudīgā DataFrame struktūrā.

Secinājums: Jūsu Pamats Datu Meistarībai

Pandas DataFrame ir centrālā datu struktūra jebkuram nopietnam datu darbam Python. Kā mēs redzējām, Pandas piedāvā elastīgu un intuitīvu rīku kopumu šo struktūru inicializēšanai no dažādiem formātiem. Izprotot, kā izveidot DataFrame no vārdnīcām, sarakstiem un NumPy masīviem, jūs esat izveidojis stabilu pamatu saviem datu analīzes projektiem.

Galvenais ir izvēlēties metodi, kas vislabāk atbilst jūsu datu sākotnējai struktūrai. Tas ne tikai padara jūsu kodu tīrāku un lasāmāku, bet arī efektīvāku. No šejienes jūs esat gatavs pāriet uz aizraujošiem datu tīrīšanas, izpētes, pārveidošanas un vizualizācijas uzdevumiem. Laimīgu kodēšanu!